'''
Created on 17/04/2013

@author: jean
'''
import os
import pm
import unittest
import tempfile
from pm.models.Usuarios import Usuarios
from pm.models.Fases import Fases
from pm.database import db
import datetime

class PMTestCase(unittest.TestCase):
    
    def setUp(self):
        self.db_fd, pm.app.config['DATABASE'] = tempfile.mkstemp()
        pm.app.config['TESTING'] = True
        self.app = pm.app.test_client()
        
    def tearDown(self):
        os.close(self.db_fd)
        
    """---------LOGIN-----------"""
             
    def login(self, username, password):
        return self.app.post('/login', data=dict(
            uid=username,
            pwd=password
        ), follow_redirects=True)
       
    def test_login(self):
        import json
        assert  json.loads(self.login('admin', '99800b85d3383e3a2fb45eb7d0066a4879a9dad0').data)
    
    def cambiarPass(self, id_usuario, password_actual, password_nuevo):
        return self.app.post('/cambiarpassword', data=dict(
            id_usuario=id_usuario,
            password_actual=password_actual,
            password_nuevo= password_nuevo
        ), follow_redirects=True)
       
    def test_cambiarPass(self):
        import json
        assert json.loads(self.cambiarPass(1, '99800b85d3383e3a2fb45eb7d0066a4879a9dad0', '0f3fde0103dd44077c040215a2fabd09a097aecc').data)
    
    def recuperarMail(self, user_name):
        return self.app.post('/recuperacionmail', data=dict(
            user_name=user_name,
        ), follow_redirects=True)
       
    def test_recuperarMail(self):
        import json
        assert json.loads(self.recuperarMail('admin').data)
        
    """--------USUARIOS-------"""
    
    def listarUsuarios(self):
        return self.app.post('/usuario/listar',data=dict(
        ), follow_redirects=True)
        
    def test_listarUsuarios(self):
        import json
        assert json.loads(self.listarUsuarios().data)
        
    def crearUsuarios(self):
        return self.app.post('/usuario/crear',data=dict(
             nombre = 'Julio',
             apellido = 'Benitez',
             direccion = 'Lomas Valentinas',
             user_name = 'jbenitez',
             password = '0f3fde0103dd44077c040215a2fabd09a097aecc',
             correo ='selazich@yahoo.com',
             activo = True,
             telefono = '232295',
             cedula = '500500'
        ), follow_redirects=True)
        
    def test_crearUsuarios(self):
        import json
        assert json.loads(self.crearUsuarios().data)
      
    def modificarUsuario(self,id, name, apell, dir, tel, correo, activo, ci):
        return self.app.post('/usuario/modificar',data=dict(
            id = id,
            nombre = name, 
            apellido= apell,
            direccion = dir, 
            telefono = tel, 
            correo = correo, 
            activo = activo, 
            cedula=ci
        ), follow_redirects=True)
        
    def test_modificarUsuario(self):
        import json
        assert json.loads(self.modificarUsuario(11,'Ricardo','Benegas', 'San Mateo N 401', '0985501235', 'darienhimura@gmail.com', False,'4305297').data)
    
    """--------ROLES---------"""
    
    def listarRol(self):
            return self.app.post('/roles/listar',data=dict(), follow_redirects=True)
        
    def test_listarRol(self):
        import json
        assert json.loads(self.listarRol().data)
             
    def crearRol(self, nombre, descripcion, activo, abreviacion):
        return self.app.post('/roles/crear',data=dict(
            nombre= nombre,
            descripcion= descripcion, 
            activo = activo, 
            abreviacion= abreviacion
        ), follow_redirects=True)
        
    def test_crearRol(self):
        import json
        assert json.loads(self.crearRol('ROL_PRUEBA', 'Rol de Prueba para el PYunit', True, 'PRU').data)  
     
    def modificarRol(self):
        return self.app.post('/roles/modificar',data=dict(
            id = 5,
            nombre= 'ROL_PRUEBA_MOD',
            descripcion= 'Modificacion del Rol de prueba de Pyunit', 
            activo = True, 
            abreviacion= 'PRUM'
        ), follow_redirects=True)
        
    def test_modificarRol(self):
        import json
        assert json.loads(self.modificarRol().data)
        
    def asignarRolToUsuario(self):
        return self.app.post('/roles/asignaroltousuario',data=dict(
            id_rol= 4,
            id_usuario= 7, 
            activo = True
        ), follow_redirects=True)
      
    def test_asignarRolToUsuario(self):
        import json
        assert json.loads(self.asignarRolToUsuario().data) 
   
    def listarRolesByIdUsuario(self):
        return self.app.post('/roles/listarbyusuario',data=dict(
           id = 2
        ), follow_redirects=True)
        
    def test_listarRolesByIdUsuario(self):
        import json
        assert json.loads(self.listarRolesByIdUsuario().data)  
        
    def listarRolesDistinct(self):
        return self.app.post('/roles/listardistinct',data=dict(
           id = 3
        ), follow_redirects=True)
        
    def test_listarRolesDistinct(self):
        import json
        assert json.loads(self.listarRolesDistinct().data)  
        
    def listarUsuariosByRol(self, idRol):
        return self.app.post('/roles/getusuariosbyroles',data=dict(
             id = idRol
        ), follow_redirects=True)
        
    def test_listarUsuariosByRol(self):
        import json
        assert json.loads(self.listarUsuariosByRol(2).data)
    
    """--------PERMISOS-------"""
    
    def listarPermisos(self):
        return self.app.post('/permisos/listar',data=dict(

        ), follow_redirects=True)
        
    def test_listarPermisos(self):
        import json
        assert json.loads(self.listarPermisos().data)
        
    def listarPermisosByRol(self, idrol):
        return self.app.post('/permisos/listarbyrol',data=dict(
             id = idrol
        ), follow_redirects=True)
            
    def test_listarPermisosByRol(self):
        import json
        assert json.loads(self.listarPermisosByRol(1).data)
        
    def crearPermiso(self, name, desc, acti):
        return self.app.post('/permisos/crear',data=dict(
           nombre= name,
           descripcion= desc,
           activo = acti
       ), follow_redirects=True)
    
    def test_crearPermiso(self):
        import json
        assert json.loads(self.crearPermiso('CREAR_LB','Crea Lbs',True).data)
    
    def modificarPermiso(self,idPermiso, name, desc, acti):
        return self.app.post('/permisos/modificar',data=dict(
            id=idPermiso,
            nombre= name,
            descripcion= desc, 
            activo = acti
        ), follow_redirects=True)
        
    def test_modificarPermiso(self):
        import json
        assert json.loads(self.modificarPermiso(18,'ROMPER_LB','Rompe Lbs',True).data)
    
    def asignarPermiso(self,idRol,idPermiso, acti):
        return self.app.post('/permisos/asignar',data=dict(
            id_rol=idRol,
            id_permiso= idPermiso,
            activo = acti
        ), follow_redirects=True)
        
    def test_asignarPermiso(self):
        import json
        assert json.loads(self.asignarPermiso(5,18,True).data)
        
    def activarDesactivarRolPermiso(self,idRol,idPermiso, acti):
        return self.app.post('/permisos/activarDesactivar',data=dict(
            id_rol=idRol,
            id_permiso= idPermiso,
            activo = acti
        ), follow_redirects=True)
        
    def test_activarDesactivarRolPermiso(self):
        import json
        assert  json.loads(self.activarDesactivarRolPermiso(5,18,True).data)
        
    """---------PROYECTO----------"""
          
    def crearProyecto(self, desc, status, c_fases, name, fechaIni,fechaFin, user_name):
        return self.app.post('/proyectos/crear',data=dict(
           descripcion= desc,
           estado= status,
           cantidad_fases = c_fases,
           nombre= name,
           fecha_inicio= fechaIni,
           fecha_fin=fechaFin,
           user_name= user_name
       ), follow_redirects=True)
    
    def test_crearProyecto(self):
        import json
        fecha = datetime.datetime.strptime('24052010', "%d%m%Y").date()
        assert json.loads(self.crearProyecto('Proyecto de Limpieza',1,1,'Proyecto de limpieza', fecha, fecha, 'jsalcedo').data)
    
    def listarProyectos(self):
        return self.app.post('/proyectos/listar',data=dict(
           id= 'jsalcedo'
        ), follow_redirects=True)
       
    def test_listarProyectos(self):
        import json
        assert json.loads(self.listarProyectos().data)
        
    def iniciarProyecto(self):
        return self.app.post('/proyectos/cambiarestado',data=dict(
            id= 2
        ), follow_redirects=True)
       
    def test_iniciarProyecto(self):
        import json
        assert json.loads(self.iniciarProyecto().data)
        
    def abrirProyecto(self):
        return self.app.post('/proyectos/abrir',data=dict(
            id= 2
        ), follow_redirects=True)
       
    def test_abrirProyecto(self):
        import json
        assert json.loads(self.abrirProyecto().data)  
        
    def activarDesactivarRolxProyecto(self):
        return self.app.post('/proyectos/activardesactivarrolxproyecto',data=dict(
            id_proyecto= 1,
            id_usuario = 7,
            id_rol = 3
        ), follow_redirects=True)
       
    def test_activarDesactivarRolxProyecto(self):
        import json
        assert json.loads(self.activarDesactivarRolxProyecto().data) 
        
    def finalizarProyecto(self):
        return self.app.post('/proyectos/finalizar',data=dict(
            id_proyecto= 1
        ), follow_redirects=True)
       
    def test_finalizarProyecto(self):
        import json
        assert json.loads(self.finalizarProyecto().data) 
    
    def listarFasesProyectos(self):
        return self.app.post('/fases/listarfasesproyecto',data=dict(
            id = 1
        ), follow_redirects=True)
       
    def test_listarFasesProyectos(self):
        import json
        assert json.loads(self.listarFasesProyectos().data)
    
    def listarUsuariosByProyecto(self, idProyecto):
        return self.app.post('/proyectos/listarusuariosbyproyecto',data=dict(
            id = idProyecto                                                                 
        ), follow_redirects=True)
        
    def test_listarUsuariosByProyecto(self):
        import json
        assert json.loads(self.listarUsuariosByProyecto(2).data)
        
    def activarDesactivar(self, idProyecto, activo):
        return self.app.post('/proyectos/activardesactivar',data=dict(
             activo = activo,
             id_proyecto = idProyecto
        ), follow_redirects=True)
        
    def test_activarDesactivar(self):
        import json
        assert json.loads(self.activarDesactivar(1,True).data)
             
    def asignarUsuarioAProyecto(self,idUsuario, idProyecto):
        return self.app.post('/usuario/asignarusuarioaproyecto',data=dict(
            id_proyecto = idProyecto,
            id_usuario = idUsuario                                                               
        ), follow_redirects=True)
        
    def test_asignarUsuarioAProyecto(self):
        import json
        assert json.loads(self.asignarUsuarioAProyecto(2,1).data)
    
    def listarProyectosByUsuario(self, idUsuario):
        return self.app.post('/usuario/listarproyectosbyusuario',data=dict(
             id = idUsuario
        ), follow_redirects=True)
        
    def test_listarProyectosByUsuario(self):
        import json
        assert json.loads(self.listarProyectosByUsuario(4).data)
     
    def listarUsuariosDistinctPorProyecto(self,idProyecto):
        return self.app.post('/proyectos/listarusuariosdistinct',data=dict(
            id_proyecto = idProyecto                                                               
        ), follow_redirects=True)
        
    def test_listarUsuariosDistinctPorProyecto(self):
        import json
        assert json.loads(self.listarUsuariosDistinctPorProyecto(1).data)
        
    def retornarFase(self, idUsuario):
        return self.app.post('/fases/retornarfase',data=dict(
             id_fase = 2
        ), follow_redirects=True)
    
        
    """---------FASES--------"""
        
    def test_retornarFase(self):
        import json
        assert json.loads(self.retornarFase(4).data) 
        
    def listarFasesPorUsuario(self):
        return self.app.post('/fases/listarfasesporusuario',data=dict(
             id_usuario = 4,
             id_proyecto = 1
        ), follow_redirects=True)
        
    def test_listarFasesPorUsuario(self):
        import json
        assert json.loads(self.listarFasesPorUsuario().data) 
        
    def crearFase(self):
        return self.app.post('/fases/crear',data=dict(
             nombre = 'Fase Prueba PyUnit',
             descripcion = 'Fase de prueba',
             posicion = 1,
             id_proyecto = 2,
             activo = True
        ), follow_redirects=True)
        
    def test_crearFase(self):
        import json
        assert json.loads(self.crearFase().data) 
    
    def modificarFases(self,id,nombre,descripcion, posicion, estado,id_proyecto):
        return self.app.post('/fases/modificar', data=dict(
                       id=id,
                       nombre=nombre,
                       descripcion=descripcion,
                       posicion=posicion,
                       estado=estado,
                       id_proyecto=id_proyecto), follow_redirects= True)
   
    def test_modificarFases(self):
        import json
        assert json.loads(self.modificarFases(2,'fase1','Fase Final',1,2,1).data)
    
    def abrirFase(self):
        return self.app.post('/fases/abrir', data=dict(
        id_fase = 1,
        id_usuario = 4), follow_redirects= True)
   
    def test_abrirFase(self):
        import json
        assert json.loads(self.abrirFase().data)
        
    def activarDesactivarRolxFase(self):
        return self.app.post('/fases/activarDesactivarRolxFase', data=dict(
            id_fase = 1,
            id_usuario= 4,
            id_rol = 2,
            activo = False
            
        ), follow_redirects= True)
   
    def test_activarDesactivarRolxFase(self):
        import json
        assert json.loads(self.activarDesactivarRolxFase().data)
        
    def estadoRelacionRolxFase(self,id_fase,id_usuario,id_rol):
        return self.app.post('/fases/estadorelacionrolxfase',data=dict(
             id_fase=id_fase,
             id_usuario=id_usuario,
             id_rol=id_rol
        ), follow_redirects=True)
    
    def test_estadoRelacionRolxFase(self):
        import json
        assert json.loads(self.estadoRelacionRolxFase(1, 1, 1).data)
        
    def asignarUsuarioAFase(self):
        return self.app.post('/fases/asignarusuarioafase', data=dict(
            id_fase = 1,
            id_usuario= 4,
            id_rol = 2,
            activo = False
            
        ), follow_redirects= True)
   
    def test_asignarUsuarioAFase(self):
        import json
        assert json.loads(self.asignarUsuarioAFase().data)
        
    def cerrarFase(self,idFase):
        return self.app.post('/fases/cerrarfase',data=dict(
             id_fase = idFase,
        ), follow_redirects=True)
    
    def test_cerrarFase(self):
        import json
        assert json.loads(self.cerrarFase(1).data)
        
    """----------TIPO ITEM----------"""
        
    def listarTipoItem(self):
        return self.app.post('/tipoitem/listartipoitem', data=dict(
        ), follow_redirects= True)
   
    def test_listarTipoItem(self):
        import json
        assert json.loads(self.listarTipoItem().data)
        
    def crearTipoItem(self):
        return self.app.post('/tipoitem/crear', data=dict(
            codigo = 'Pyunit',
            descripcion = 'Tipo de Dato Pyunit',
            activo = True,
            id_fase = 1
        ), follow_redirects= True)
   
    def test_crearTipoItem(self):
        import json
        assert json.loads(self.crearTipoItem().data)
        
    def modificarTipoItem(self):
        return self.app.post('/tipoitem/modificar', data=dict(
            id = 1,
            codigo = 'Pyunit Mod',
            descripcion = 'Tipo de Dato Pyunit Mod',
        ), follow_redirects= True)
   
    def test_modificarTipoItem(self):
        import json
        assert json.loads(self.modificarTipoItem().data)
    
    def activarDesactivarTipoItem(self):
        return self.app.post('/tipoitem/activardesactivar', data=dict(
            id = 1,
            activo = False
        ), follow_redirects= True)
   
    def test_activarDesactivarTipoItem(self):
        import json
        assert json.loads(self.activarDesactivarTipoItem().data)
        
    def listarTipoItemByFaseDistinct(self):
        return self.app.post('/tipoitem/listardistinct', data=dict(
            id_fase= 3,
        ), follow_redirects= True)
   
    def test_listarTipoItemByFaseDistinct(self):
        import json
        assert json.loads(self.listarTipoItemByFaseDistinct().data)
        
    def importarTipoItem(self,id_tipo_item, id_fase):
        return self.app.post('/tipoitem/importar',data=dict(
            id_tipo_item=id_tipo_item,
            id_fase =id_fase
        ), follow_redirects=True)
        
    def test_importarTipoItem(self):
        import json
        assert json.loads(self.importarTipoItem(1,2).data)
        
        
    """---------ATRIBUTOS--------"""
        
    def listarAtributos(self):
        return self.app.post('/atributos/listaratributos',data=dict(                                            
        ), follow_redirects=True)
        
    def test_listarAtributos(self):
        import json
        assert json.loads(self.listarAtributos().data)
       
    def modificarAtributo(self, nombre,tipo, activo, idAtributo):
        return self.app.post('/atributos/modificar',data=dict( 
            nombre_atributo = nombre,
            tipo =  tipo,
            activo = activo,
            id_atributo =idAtributo                                                 
        ), follow_redirects=True)
        
    def test_modificarAtributo(self):
        import json
        assert json.loads(self.modificarAtributo('Atributo Prueba', 'Cadena', True, 1).data)
        
    def listarAtributosByTipoItem(self, id):
        return self.app.post('/atributos/listaratributosbytipoitem',data=dict(
             id_tipo_item = id
        ), follow_redirects=True)
        
    def test_listarAtributosByTipoItem(self):
        import json
        assert json.loads(self.listarAtributosByTipoItem(1).data)
        
    def importarAtributo(self,id_tipo_item, id_atributo):
        return self.app.post('/atributos/importar',data=dict(
            id_tipo_item=id_tipo_item,
            id_atributo =id_atributo
        ), follow_redirects=True)
        
    def test_importarAtributo(self):
        import json
        assert json.loads(self.importarAtributo(2,2).data)
        
    def listarAtributosDistinct(self):
        return self.app.post('/atributos/listardistinct', data=dict(
            id_tipo_item = 3
        ), follow_redirects= True)
   
    def test_listarAtributosDistinct(self):
        import json
        assert json.loads(self.listarAtributosDistinct().data)
        
        
    """---------ITEMS---------"""
        
    def listarItemsByFase(self, id):
        return self.app.post('/items/listaritems',data=dict(
             id_fase = id
        ), follow_redirects=True)
        
    def test_listarItemsByFase(self):
        import json
        assert json.loads(self.listarItemsByFase(1).data)
        
    def crearItem(self, id_fase,id_tipo_item,complejidad, descripcion, observacion,prioridad):
        return self.app.post('/items/crear',data=dict(
             id_fase = id_fase,
             id_tipo_item = id_tipo_item,
             complejidad = complejidad,
             descripcion= descripcion,
             observacion = observacion,
             prioridad = prioridad
        ), follow_redirects=True)
        
    def test_crearItem(self):
        import json
        assert json.loads(self.crearItem(1, 1, 3, 'Item de prueba', 'este Item es importantisimo', 9).data)
    
    def modificarItem(self,id_item, id_tipo_item,complejidad, descripcion, observacion,prioridad):
        return self.app.post('/items/modificar',data=dict(
             id_item = id_item,
             id_tipo_item = id_tipo_item,
             complejidad = complejidad,
             descripcion= descripcion,
             observacion = observacion,
             prioridad = prioridad
        ), follow_redirects=True)
        
    def test_modificarItem(self):
        import json
        assert json.loads(self.modificarItem(1, 1,5, 'Item de prueba modificado', 'este Item es no tan importantisimo', 8).data)
     
    def aprobarItem(self,id_item):
        return self.app.post('/items/aprobar',data=dict(
             id_item = id_item
        ), follow_redirects=True)
        
    def test_aprobarItem(self):
        import json
        assert json.loads(self.aprobarItem(1).data) 
        
    def desaprobarItem(self,id_item):
        return self.app.post('/items/desaprobar',data=dict(
             id_item = id_item
        ), follow_redirects=True)
        
    def test_desaprobarItem(self):
        import json
        assert json.loads(self.desaprobarItem(1).data)  
        
    def getVersionesPorItem(self, id):
        return self.app.post('/items/listarversionesporitem',data=dict(
             id_item = id
        ), follow_redirects=True)
        
    def test_getVersionesPorItem(self):
        import json
        assert json.loads(self.getVersionesPorItem(1).data)
        
    def eliminarItem(self,id_item):
        return self.app.post('/items/eliminaritem',data=dict(
             id_item = id_item,
        ), follow_redirects=True)
    
    def test_eliminarItem(self):
        import json
        assert json.loads(self.eliminarItem(4).data)
        
    def revivirItem(self,id_item):
        return self.app.post('/items/reviviritem',data=dict(
             id_item = id_item,
        ), follow_redirects=True)
    
    def test_revivirItem(self):
        import json
        assert json.loads(self.revivirItem(4).data)
        
    def revertirItem(self,id_historial_item):
        return self.app.post('/items/revertir',data=dict(
             id_historial_item = id_historial_item,
        ), follow_redirects=True)
    
    def test_revertirItem(self):
        import json
        assert json.loads(self.revertirItem(1).data)
    
    def asignarValorAAtributo(self,id_atributo,id_item,tipo_dato,valor):
        return self.app.post('/items/asignarvaloratributo',data=dict(
            id_atributo = id_atributo,
            id_item= id_item,
            tipo_dato= tipo_dato,
            valor= valor,
        ), follow_redirects=True)
        
    def test_asignarValorAAtributo(self):
        import json
        assert json.loads(self.asignarValorAAtributo(1,1,1, 'Atributo no Default').data)
           
    def listarAtributoValor(self, id_item ):
        return self.app.post('/items/listaratributovalor',data=dict(
            id_item= id_item
        ), follow_redirects=True)
        
    def test_listarAtributoValor(self):
        import json
        assert json.loads(self.listarAtributoValor(1).data)
        
        
    """---------RELACIONES--------"""
        
    def relacionPadreHijoItem(self):
        return self.app.post('/relaciones/padrehijoitem',data=dict(
            id_origen= 1,
            id_destino = 2
        ), follow_redirects=True)
        
    def test_relacionPadreHijoItem(self):
        import json
        assert json.loads(self.relacionPadreHijoItem().data)
        
    def relacionAntecesorSucesorItem(self):
        return self.app.post('/relaciones/antecesorsucesoritem',data=dict(
            id_origen= 1,
            id_destino = 5
        ), follow_redirects=True)
        
    def test_relacionAntecesorSucesorItem(self):
        import json
        assert json.loads(self.relacionAntecesorSucesorItem().data)
        
    def listarItemHijos(self):
        return self.app.post('/relaciones/listaritemshijos',data=dict(
            id= 1,
        ), follow_redirects=True)
        
    def test_listarItemHijos(self):
        import json
        assert json.loads(self.listarItemHijos().data)
        
    def listarItemSucesores(self):
        return self.app.post('/relaciones/listaritemssucesores',data=dict(
            id= 1
        ), follow_redirects=True)
        
    def test_listarItemSucesores(self):
        import json
        assert json.loads(self.listarItemSucesores().data)
        
    def listarItemPadres(self):
        return self.app.post('/relaciones/listaritemsPadres',data=dict(
            id= 2
        ), follow_redirects=True)
        
    def test_listarItemPadres(self):
        import json
        assert json.loads(self.listarItemPadres().data)
        
    def listarItemPosiblesHijos(self):
        return self.app.post('/relaciones/listarposibleshijos',data=dict(
            id_item= 1
        ), follow_redirects=True)
        
    def test_listarItemPosiblesHijos(self):
        import json
        assert json.loads(self.listarItemPosiblesHijos().data)
              
    def listarItemPosiblesAntecesores(self):
        return self.app.post('/relaciones/listarposiblesAntecesores',data=dict(
            id_item= 1
        ), follow_redirects=True)
        
    def test_listarItemPosiblesAntecesores(self):
        import json
        assert json.loads(self.listarItemPosiblesAntecesores().data)
        
    def activarDesactivarRelacion(self):
        return self.app.post('/relaciones/eliminarrelacion',data=dict(
            id_origen= 1,
            id_destino = 2,
            activo= True
        ), follow_redirects=True)
        
    def test_activarDesactivarRelacion(self):
        import json
        assert json.loads(self.activarDesactivarRelacion().data)
        
    def obtenerEstadoRelacion(self):
        return self.app.post('/relaciones/estadorelacion',data=dict(
            id_origen= 1,
            id_destino = 2
        ), follow_redirects=True)
        
    def test_obtenerEstadoRelacionn(self):
        import json
        assert json.loads(self.obtenerEstadoRelacion().data)
        
    def calcularImpacto(self):
        return self.app.post('/relaciones/calcularimpacto',data=dict(
            id_item= 2,
            complejidad = 2
        ), follow_redirects=True)
        
    def test_calcularImpacto(self):
        import json
        assert json.loads(self.calcularImpacto().data)
        
        
    """---------LINEA BASE--------"""
        
    def listarLineaBase(self):
        return self.app.post('/lineabase/listar',data=dict(
            id_fase= 2
        ), follow_redirects=True)
        
    def test_listarLineaBase(self):
        import json
        assert json.loads(self.listarLineaBase().data)
        
     
    def listarItemsDistinctByFase(self):
        return self.app.post('/lineabase/listaritemsdistinct',data=dict(
            id_fase= 1
        ), follow_redirects=True)
        
    def test_listarItemsDistinctByFase(self):
        import json
        assert json.loads(self.listarItemsDistinctByFase().data)
        
     
    def eliminarLineaBase(self):
        return self.app.post('/lineabase/eliminar',data=dict(
            id_linea_base = 1
        ), follow_redirects=True)
        
    def test_eliminarLineaBase(self):
        import json
        assert json.loads(self.eliminarLineaBase().data)
        
    def LineaBaseRevisado(self):
        return self.app.post('/lineabase/revisado',data=dict(
            id_linea_base = 1
        ), follow_redirects=True)
        
    def test_LineaBaseRevisado(self):
        import json
        assert json.loads(self.LineaBaseRevisado().data)
        
    def crearSolicitudDeCambio(self):
        return self.app.post('/solicitudcambio/crear',data=dict(
            id_usuario =2,
            observacion= 'Creacion de Prueba',
            id_items = 2
        ), follow_redirects=True)
        
        
    """---------SOLICITUD CAMBIO---------"""
        
    def test_crearSolicitudDeCambio(self):
        import json
        assert json.loads(self.crearSolicitudDeCambio().data)
        
    def enviarSolicitudDeCambioAComite(self):
        return self.app.post('/solicitudcambio/enviarsolicitud',data=dict(
            id_solicitud_cambio =1,
            id_proyecto= 2
        ), follow_redirects=True)
        
    def test_enviarSolicitudDeCambioAComite(self):
        import json
        assert json.loads(self.enviarSolicitudDeCambioAComite().data)
         
    def votarSolicitudDeCambio(self):
        return self.app.post('/solicitudcambio/votarsolicituddecambio',data=dict(
            id_solicitud_cambio =1,
            id_proyecto= 1,
            id_usuario = 1,
            voto= 'true'
        ), follow_redirects=True)
        
    def test_votarSolicitudDeCambio(self):
        import json
        assert json.loads(self.votarSolicitudDeCambio().data)
        
    def ejecutarSolicitudCambio(self):
        return self.app.post('/solicitudcambio/ejecutar',data=dict(
           id_solicitud_cambio = 1
        ), follow_redirects=True)
        
    def test_ejecutarSolicitudCambio(self):
        import json
        assert json.loads(self.ejecutarSolicitudCambio().data)
        
    def modificarSolicitudDeCambio(self):
        return self.app.post('/solicitudcambio/modificar',data=dict(
           id_usuario = 2,
           observacion ='Obs Prueba',
           id_items = 1,
           id_solicitud_cambio = 1
        ), follow_redirects=True)
        
    def test_modificarSolicitudDeCambio(self):
        import json
        assert json.loads(self.modificarSolicitudDeCambio().data)
     
        
    """---------MIEMBROS COMITE--------"""    
         
    def agregarMiembrosComite(self):
        return self.app.post('/miembroscomite/agregar',data=dict(
           id_usuarios = 3,
           id_proyecto =2
        ), follow_redirects=True)
        
    def test_agregarMiembrosComite(self):
        import json
        assert json.loads(self.agregarMiembrosComite().data)
        
    def modificarMiembroComite(self):
        return self.app.post('/miembroscomite/modificar',data=dict(
           id_usuarios = 3,
           id_usuario_modificar = 8,
           id_proyecto =2
        ), follow_redirects=True)
        
    def test_modificarMiembroComite(self):
        import json
        assert json.loads(self.modificarMiembroComite().data)
        
    def listarComite(self):
        return self.app.post('/miembroscomite/listar',data=dict(
            id = 1                                                   
        ), follow_redirects=True)
        
    def test_listarComite(self):
        import json
        assert json.loads(self.listarComite().data)
        
    def listarComiteDistinct(self):
        return self.app.post('/miembroscomite/listardistinct',data=dict(
            id = 1                                                   
        ), follow_redirects=True)
        
    def test_listarComiteDistinct(self):
        import json
        assert json.loads(self.listarComiteDistinct().data)